﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using Noris.Schedule.Support.Services;
using System.Drawing;
using System.Windows.Forms;

namespace Noris.Schedule.Planning.Services
//namespace Noris.Schedule.UI.Functions
{
	/// <summary>
	/// Funkce pro rozdělení položky práce vedví
	/// </summary>
	internal class SplitWorkItem : IFunctionMenuItem
	{
		/// <summary>
		/// Tady funkce deklaruje, pro které případy chce být vidět v nabídce.
		/// A pokud ano, tak jak se jmenuje, kde v nabídce je a jaký má obrázek.
		/// </summary>
		/// <param name="args"></param>
		/// <returns></returns>
		bool IFunctionMenuItem.IsFunctionSuitableFor(FunctionMenuItemSuitableArgs args)
		{
			bool isSuitable = (args.KeyGraphMode == RowGraphMode.TaskCapacityLink &&
				args.KeyAreaType == FunctionMenuItemAreaType.GraphElement &&
				args.KeyElementClassNumber == Noris.Schedule.Planning.ProcessData.Constants.ClassNumberWork);
			if (isSuitable)
			{
				args.MenuCaption = "Rozdělit práci";
				args.MenuToolTipText = "Zajistí rozdělení operace na paralelní průchody";
				args.MenuImage = PicLibrary.Scissors_24_FromFile;
				args.MenuGroup = "TASK";
			}
			return isSuitable;
		}
		bool IFunctionMenuItem.IsMenuItemEnabledFor(FunctionMenuItemRunArgs args)
		{
			return true;
		}
		/// <summary>
		/// Vstupní metoda do výkonné části pluginu
		/// </summary>
		/// <param name="args"></param>
		void IFunctionMenuItem.Run(FunctionMenuItemRunArgs args)
		{ }
	}

	/// <summary>
	/// Funkce pro rozdělení položky práce vedví
	/// </summary>
	internal class JoinWorkItem : IFunctionMenuItem
	{
		/// <summary>
		/// Tady funkce deklaruje, pro které případy chce být vidět v nabídce.
		/// A pokud ano, tak jak se jmenuje, kde v nabídce je a jaký má obrázek.
		/// </summary>
		/// <param name="args"></param>
		/// <returns></returns>
		bool IFunctionMenuItem.IsFunctionSuitableFor(FunctionMenuItemSuitableArgs args)
		{
			bool isSuitable = (args.KeyGraphMode == RowGraphMode.TaskCapacityLink && 
				args.KeyAreaType == FunctionMenuItemAreaType.GraphElement && 
				args.KeyElementClassNumber == Noris.Schedule.Planning.ProcessData.Constants.ClassNumberWork);
			if (isSuitable)
			{
				args.MenuCaption = "Spojit práci";
				args.MenuToolTipText = "Zajistí sloučení paralelních průchodů do jednoho";
				args.MenuImage = PicLibrary.Shuffle_24_FromFile;
				args.MenuGroup = "TASK";
				args.EnabledStateDependingOnElement = true;
			}
			return isSuitable;
		}
		bool IFunctionMenuItem.IsMenuItemEnabledFor(FunctionMenuItemRunArgs args)
		{
			return (args.SelectedElements.Count > 1);
		}
		/// <summary>
		/// Vstupní metoda do výkonné části pluginu
		/// </summary>
		/// <param name="args"></param>
		void IFunctionMenuItem.Run(FunctionMenuItemRunArgs args)
		{ }
	}

	/// <summary>
	/// Funkce pro změnu pracovních směn
	/// </summary>
	internal class ChangeWorkShift : IFunctionMenuItem
	{
		/// <summary>
		/// Tady funkce deklaruje, pro které případy chce být vidět v nabídce.
		/// A pokud ano, tak jak se jmenuje, kde v nabídce je a jaký má obrázek.
		/// </summary>
		/// <param name="args"></param>
		/// <returns></returns>
		bool IFunctionMenuItem.IsFunctionSuitableFor(FunctionMenuItemSuitableArgs args)
		{
			bool isSuitable = ((args.KeyGraphMode == RowGraphMode.TaskCapacityLink || 
						args.KeyGraphMode == RowGraphMode.CapacityUtilization) &&
				args.KeyRowClassNumber == Noris.Schedule.Planning.DataFace.PlanUnitCCls.ClassNr);
			if (isSuitable)
			{
				args.MenuCaption = "Změnit pracovní kalendář";
				args.MenuToolTipText = "Umožní přidat / ubrat pracovní směny";
				args.MenuImage = PicLibrary.Column_chart_24_FromFile;
				args.MenuGroup = "CAPACITY";
			}
			return isSuitable;
		}
		bool IFunctionMenuItem.IsMenuItemEnabledFor(FunctionMenuItemRunArgs args)
		{
			return true;
		}
		/// <summary>
		/// Vstupní metoda do výkonné části pluginu
		/// </summary>
		/// <param name="args"></param>
		void IFunctionMenuItem.Run(FunctionMenuItemRunArgs args)
		{
			MessageBox.Show("Zatím zde není žádná funkce.", "Změnit pracovní kalendář", MessageBoxButtons.OK);
		}
	}
	internal static class PicLibrary
	{
		#region Image Scissors_24
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku scissors_24.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Scissors_24_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Scissors_24, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Scissors_24_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// C:\David\CsProj\GreenSchedule\Schedule\Images\scissors_24.png
		/// </remarks>
		public static System.Drawing.Image Scissors_24_Cached
		{
			get
			{
				if (_Scissors_24 == null) _Scissors_24 = Scissors_24;
				return _Scissors_24;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku scissors_24.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Scissors_24_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Scissors_24_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Scissors_24_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// C:\David\CsProj\GreenSchedule\Schedule\Images\scissors_24.png
		/// </remarks>
		public static System.Drawing.Image Scissors_24 { get { return _ImageCreateFrom(_Scissors_24_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru scissors_24.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Scissors_24_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Scissors_24_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// C:\David\CsProj\GreenSchedule\Schedule\Images\scissors_24.png
		/// </remarks>
		public static System.Drawing.Image Scissors_24_FromFile { get { return _ImageCreateFrom(_Scissors_24_string, "scissors_24.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Scissors_24
		/// </summary>
		/// <returns></returns>
		private static string _Scissors_24_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1796);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAsSAAALEgHS3X78AAAACXZwQWcAAAAYAAAAGAB4TKWmAAAE");
			sb.Append("mUlEQVRIx72VW0xUVxSG19lzLjOHuTAzhUGiRJKG0toaKFFEWpxyaSBGm6aX2KaxVoWqpA821ETxgn0QlRSRWKq0BCv10kCNqG1j2mIJKII4mFAVBqWozA1mhrmfw5k5");
			sb.Append("Z/epROPgaJt2ve29//1/WevPzgb4j4uIttnbdxVohmbFiLjs+oDposfj4SsqKh7S9Pf3g0ajIf2BYOHAgOkKy7Ke91atesQLRQNgjIHjeELOKj54Lj198frS0kc0iYmJ");
			sb.Append("QFH0Qoqm11ltNsrpdEbtICoAYRF0iYagIERM8Vrd2t07dzDV1dUz59euXYMx87AMI2Ktz+8f2lFZ6dy/d++TjwgAoKOrGwBggV6nOxX0eTfnLFnyK0IIMMZwf3wcRFHM");
			sb.Append("5qbDTaYBU9lr+QWXkxP0UX3I2QA0ImBywmGmaOaWRq3ZsL1y2+UvamtDOUuXwvDNG2RqWvoGt9d7/+dzZwfNt27OGvKsAB1Lw4RcGfb6fGcYhqkvWb7CmLs05yfznVHQ");
			sb.Append("xmtzAhy33G63VbW0tPhpmp4VgGY7eCFzEShIBBFhutPj8zlZlWpj1e4qpcMyTkcw3uhye7ix0dGOzss9EA6Hn74DAAAFRUJJUaHlVPv5CwxNl72aZyyQK1V+X5Bb4XS5");
			sb.Append("2hoP1o4uyMx6nMXsIf9dR0+1AkFAAUnR5+bNMfSKEhZ8wZDRbhl/v2zN6h8I4vEWZCyAOk4BpEzWPzpuNTEUZZQAg8s9NWC7N9bTdKwl1vXYAJ1aCV+dbPMuXvji+Vsj");
			sb.Append("I7kSxsDIZBc+37XLlpaWFhOAYgmMy4yQk/ESyBm6z+awcxOTDkGMCH2/9V7FZrP53wO6e3qgseUEWG32LJfbrXBPeegQz79ckL0IiouLYwJihrzvYD3QFDXPNDj4IyIQ");
			sb.Append("iWQyRABGBp12pVoTP7T1083/rIOL3Z3Q2PwtPDt/fsqUx7sHS5JczcpL5yYZPhJFEbNK1Z7UlJTnMcaw6ZPypwN0dHeBMTcPCILItlhsJ5Rs3DtJCQn76mtqLlms9p4F");
			sb.Append("6ekVWk18fojjv2/+7niJUqVGNQcOPNmIjjQfBbVazZiHhlfz08JOuVw+V6vVtrucjnV6/TMunV4POr2WGh66XRcMBjcRAE4Ji3tkpOwIYAht++zhf0P24KLhmybQ6rT0");
			sb.Append("zcEb26xW68cj5iEgSYqMj9dseSXPOPjum2/A6bZWyMzKlghETLpd7rcmHPaAc3IyIxgIJpMUeSm/sCjc2dERfUQOxyTcuT1aKGFpOcNQHyYaElfzPDfu9Xodd++Nzegw");
			sb.Append("YOB53o0QYVdpVOVsnOJtr8eT67A7ViYYkuHB1/0QAJEkUDS9MMGQNHyorq6XZeM0CoVCEAQhFAgEHlBikCQpFJGkUJxSpfm6oekPAhHXQyEuq3z9GkAIRQcQACBK0gDI");
			sb.Append("ZBn76w8djkTEaiDQL31Xuv482XJsRjcnOQm2b6mwiaLYTjLyypqGusNKtSYPIdR/vO0sSJIUPYPXS4oBAdydcnssfp8vVZgWzkhS5EhRyYrQlwdqZ3SnW1th664qUKtV");
			sb.Append("/RzHOwN+/7ywED7Oc8H2cHg60vX7Rfjf6i9SwgUHZaWJBQAAACh6VFh0U29mdHdhcmUAAHja801MLsrPTU3JTFRwyyxKLc8vyi5WsAAAYBUIJ4KDNosAAAAASUVORK5C");
			sb.Append("YII=");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Scissors_24_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Scissors_24_Reset()
		{
			_Scissors_24 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Scissors_24_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Scissors_24 = null;
		#endregion
		#region Image Column_chart_24
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku column_chart_24.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Column_chart_24_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Column_chart_24, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Column_chart_24_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// C:\David\CsProj\GreenSchedule\Schedule\Images\column_chart_24.png
		/// </remarks>
		public static System.Drawing.Image Column_chart_24_Cached
		{
			get
			{
				if (_Column_chart_24 == null) _Column_chart_24 = Column_chart_24;
				return _Column_chart_24;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku column_chart_24.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Column_chart_24_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Column_chart_24_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Column_chart_24_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// C:\David\CsProj\GreenSchedule\Schedule\Images\column_chart_24.png
		/// </remarks>
		public static System.Drawing.Image Column_chart_24 { get { return _ImageCreateFrom(_Column_chart_24_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru column_chart_24.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Column_chart_24_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Column_chart_24_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// C:\David\CsProj\GreenSchedule\Schedule\Images\column_chart_24.png
		/// </remarks>
		public static System.Drawing.Image Column_chart_24_FromFile { get { return _ImageCreateFrom(_Column_chart_24_string, "column_chart_24.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Column_chart_24
		/// </summary>
		/// <returns></returns>
		private static string _Column_chart_24_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1828);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
			sb.Append("AAAAGAAAABgAeEylpgAABKZJREFUSMe1lE2IHFUQx/9V9d7r7tmZ2TDZNWsgGJMgCQh+gCB48+TBkx4UvCUHL6InT4KyB8GTHnLwIHjwloPgSdGTBPEkmjWI+BEFN5Dd");
			sb.Append("NbvZmdnu6e73UR5md7KTRchBC7pf815V/6qK/yvgfzb65MoV88j5C0UbItau/VApEF+/dPE/A5jbo/Lpza+/fndStyE/NnjNWvPzYYeXLr6FO5vjggYn3zj1yINnBoud");
			sb.Append("dHKph5NLfRTC/M3V618+89Rzn377/cd47+13jgLKST347urVpzY2t+LzL7x4odrdrldXVwUAoAoi6J/k+rtl8cqrLzz76LHFDpwRFLnFb79s4Ke1TbuYf3StUOHV1dXZ");
			sb.Append("j1NKCuCWYSJtmhZlWSYSUwZCq6pijYGxFlnmVDJtpOTQL3J0cgtVIMSEctKiLEP5wAO8sXFL+HDmKSVV1cYQ0TRZIMW6evnJx594bDAYIMtzdIoCRVHQt4Pvdj77fHPx");
			sb.Append("71GFSQpQBZgJ46oFWMKli2Zy+fLCDKCqGI1GCCFEAyIkTSAC+aY+t3LixBOnT58GVAEiqCrGo+HthBjujGvUMQLYB9Qt8g4vfvB+OlM3e3OAEOOsRdCUAEUi5jJ4j7Zt");
			sb.Append("kVI6KBWAhgCEnVGF3Nup/JgwqlpE8F6ddv9e36yl1+uh3+uh1+9jeWlJ66Y5aBHBGCEhtiFGNHWNpDrLhphZGbwzniDzfgogwl7tQTR8+q8/hl+cPXsu6/f7GAwGWF5e");
			sb.Append("pt9v3Ci//OqrN42qwjkLZx0BKiEE1E0D3QcACiaiBND2aALXmBmgmrTwbXUshnDqwZWVDADapsHW5iaur63t/fbrr30TmgbGGFhrEwF1CAHNHABg5hiJ4s54AtvI/hUF");
			sb.Append("4iSCjPimqXU4HM7aysyoJhNlZjUpBmTOIXOWARTee9R1PQMQEYhJFNCd0QTG3lUjB8Ba49rW0+7u7iyGmRFDoDzPyRAUeZbBOZcIaO+tgIggzCkS0vZ4AjF3ATkJ2Ejw");
			sb.Append("Tauj0WgOEEKAcw7GECHPMzhrASDdC2BmMDMSke7u1WCZ3Rv0nUPHGvVlwHg8notJKSHLMjVGGEVRwDnHBHRoX/t6SEXMLGJIQ0pg3AUkVVhnXCSiGONcDBEhc444sxYL");
			sb.Append("nQ6cNYkI5QFgbmAZE8hIODqLAbGmZRG990hEYK1VzrNsCnCOCLDMjKPOzMbKkQNignVGRORIUiIyraAocix0uyjynEREmBkH8+mQM4llIibg0BERwVhDRoSIaC7OGINO");
			sb.Append("pwPT63YxHg5BRImZ66qqICJgZogIjDEQkZgCYr3bQCyDhUHCiEkhzvi6rhU0gogctAYionmeq+l2u/Dew2VZZ2Vl5bz3Hk3THKQIIkJMqf+w20uFKQHB9DGAtIwY907U");
			sb.Append("PpiqHcI5B+ccspiQdwpz/PhSzzjnqCxLraoq+3Ft7aGUEnwIaNsW3nu0rYf3bScEj+Q9vPcIISDGiJQStpIOoFPljDVh+p1QdLtmYfHYgllfX7/x182bH27d3s62bm9j");
			sb.Append("OvsIRAwQ9lcC2QzO5cgO9o8Ian7TWhfyPP+ZADgAx6dF/7vR/Ot+LKrqNgHgfch9R96nKYD2H3pxaQd9+KUQAAAAInpUWHRTb2Z0d2FyZQAAeNpzTMlPSlXwzE1MTw1K");
			sb.Append("TUypBAAvnAXUrgypTQAAAABJRU5ErkJggg==");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Column_chart_24_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Column_chart_24_Reset()
		{
			_Column_chart_24 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Column_chart_24_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Column_chart_24 = null;
		#endregion
		#region Image Shuffle_24
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku shuffle_24.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Shuffle_24_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Shuffle_24, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Shuffle_24_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// C:\David\CsProj\GreenSchedule\Schedule\Images\shuffle_24.png
		/// </remarks>
		public static System.Drawing.Image Shuffle_24_Cached
		{
			get
			{
				if (_Shuffle_24 == null) _Shuffle_24 = Shuffle_24;
				return _Shuffle_24;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku shuffle_24.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Shuffle_24_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Shuffle_24_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Shuffle_24_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// C:\David\CsProj\GreenSchedule\Schedule\Images\shuffle_24.png
		/// </remarks>
		public static System.Drawing.Image Shuffle_24 { get { return _ImageCreateFrom(_Shuffle_24_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru shuffle_24.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Shuffle_24_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Shuffle_24_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// C:\David\CsProj\GreenSchedule\Schedule\Images\shuffle_24.png
		/// </remarks>
		public static System.Drawing.Image Shuffle_24_FromFile { get { return _ImageCreateFrom(_Shuffle_24_string, "shuffle_24.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Shuffle_24
		/// </summary>
		/// <returns></returns>
		private static string _Shuffle_24_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(2176);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAsSAAALEgHS3X78AAAACXZwQWcAAAAYAAAAGAB4TKWmAAAF");
			sb.Append("tklEQVRIx7VVa2xUZRp+vvOd6zDTzoXSoZ2L0wLTi9CKgFssUC2uKDFeYhQvsYk12eyakPhjswLqaszqbnaz1d1NDFEUQkQWKka7SwUVpOCFprRQaEW29zJMp7eZ6cw5");
			sb.Append("Z86Zc9kfuCsGsj8WfX4/7/Pmfd88zwv8xCDXVV3vBnTKI6OZILaJfvkqCr0e/X1fHoZiGY823NbY2B8bPBtYf6OeOjX2441v2zaea23ZenKoN/9a+66dVU/fEXl5+ENA");
			sb.Append("vHJFD4CtWFuxqtQd8IkQbZERITIiRCpiOjU90X7o416H5NCn9syganNdyZIbolUSJ/KwCXK6blWFo5tc811NZZ4gDNnq/Puxti0Ht731OV3usczuJAgeg2fjExs/8nqK");
			sb.Append("6myVNbm8CN4WIVGJlEhFc+OXhl78ywMtf6vZ0rD4qQ1NO0p9JSvlvEIIc/mCDCX0nb5WdiwdQ3PtQwgx4YmjPZ2v7m7btyMUDskseBCXUMj3zw3SyUSGamkCQwFs2Ah6");
			sb.Append("/b67QnXPLHt++bE7V97XJLqkNS2n3sa0MQNOAlgRALWQsjLQeRNvjryDxpK1fv/CyJ+WLa8tOfn6ey+wDAN4GS+8dg6GLUEzCUyTgQULw/EJnHYMRJYuWfHHoD+w9MC/");
			sb.Append("DqEveR6Ck4InAM8BVAA4HmBUAtMw8X7XEWhj/HmaZU5AhUHpMkodxQUVRs5UodpDVMeQh3Mm10ZuWTCUvMhcUuLkxuJoOURScGi4A5QjgGHF82q+29TMER/ntgoKHR5F");
			sb.Append("z0GdhpGNGQeUS9lf4v7QV8bphM0aX5vZo99+8msIoBAA5GEXVPr8tcHo/psCFTf3xHuwwDOfdMS/Rp7k4WQceXli7qXJ7X27kADqdjY/a/rU344mp2flmPmacl75K1ss");
			sb.Append("pHL3tn3ngxkAF2FiFHkMIg8njO37308dOdFuRYrCdxW5Cqkl2ehMnIbEipA0vmOsd+RFocqTaf7waePM6b7Vczm5dPz81Gb53am3iZtRrL0j/8Nok8Cx5FEMjw6OuL2F");
			sb.Append("9YvD5eEvp7ogGwqKOZ8mx+e2RW+t6hr+fSfGyzVM9MdTs7H0ntv/3HTiwuvHLXTN/ECOuZaBCAA1l0Wx148xeQIJdQo+hxuSwSOnadBk7XIlQ/5DBwvxmsFz9QTVwBut");
			sb.Append("e5GZTT8W9pf/4ovYKWqQPMocAcTSk6wwzzH/3PHeNmGZR9301H1QJuXmonL3Kyf3fhYz+vQBUue1MJC5osEiAFEIWAwBUXCQwB7pPhRcX7vxD0OpRPCb2QGUe0OwVROj");
			sb.Append("SgIMzwY4jhtNtw71n3rpOFe/6fZ1BWXCg0ma/DkJzeO0GauXbSjOWd+tirBNjHPthsZXTIYuzWUtKy/DngeXuzZwU82BC4dZ26Hj7rLVNixC2sdPwCQGYJlxC/kBVoTt");
			sb.Append("9/mCopdGJlMpyAkY6WHjA3VMe154pOLb3NYOUKyAc8Oau3+T5tVb06oeUTVSllGNkguzI8ysOYsVwUpbVO3DtSW1jkxedY2mYuAcjEsopGHRQ8OmQ/fIWg6WTkAFwtg2");
			sb.Append("U01N5zr+rDqe+3RggNq1kMprFj0esydKp5UksroC2ZShMjLCC/xYs7Bm+HjXkeYFrlJaX37L6vjcNCwbcHASJCKBMwUo2Tw0xQLPsdgYbcD6heu8qUwmFus5d4yFDjuj");
			sb.Append("pfVq7yKzmudMzn857BxUgl+anxmLDbb0vtx9tmZrw/aQL7jqmZufXCUbCiEEIAwBoYTuPLefjuoxNFc/hBDCE0fjna+e6e7ZseTRO3WC+8FWNlSuDLgDPpFItkhEiIwE");
			sb.Append("iYqYSk0l/vnxwd55kkM/s2cGjZt/VhKNVFZLnMQDBDlNt6rCSx52+pxXxPU/thzc9uZ/4/pHezgt7bt2Vv3qjsjvRtsA4XsOez0N9l3sQM/wN+OJ5Myzu1t3b/ffEMxu");
			sb.Append("C99zlWn/f9QXAjrLI5MzQXDNp/+T498AzZhIedUGnAAAACh6VFh0U29mdHdhcmUAAHja801MLsrPTU3JTFRwyyxKLc8vyi5WsAAAYBUIJ4KDNosAAAAASUVORK5CYII=");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Shuffle_24_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Shuffle_24_Reset()
		{
			_Shuffle_24 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Shuffle_24_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Shuffle_24 = null;
		#endregion


		#region SPOLEČNÉ METODY PRO KONVERZI
		/// <summary>
		/// Vrátí Image z definice (string). Image generuje buď v paměti, anebo s pomocí souboru.
		/// Pokud není zadán parametr (cacheFileName) (když je null), generuje se Image v paměti.
		/// Pokud je soubor (cacheFileName) definován, pak se Image čte z něj.
		/// Pokud soubor neexistuje, nejprve se vytvoří.
		/// Umístění souboru (adresář) je dán property _ImageCacheDir, defaultně je to adresář (Sys:\Documents and Settings\All Users\Data aplikací\IconCache).
		/// Obsah obrázku definuje metoda getDataMethod.
		/// </summary>
		/// <param name="getDataMethod"></param>
		/// <param name="cacheFileName"></param>
		/// <returns></returns>
		private static System.Drawing.Image _ImageCreateFrom(_GetStringDelegate getDataMethod, string cacheFileName)
		{
			System.Drawing.Image image;
			if (cacheFileName == null)
			{
				using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(getDataMethod())))
				{
					image = System.Drawing.Image.FromStream(ms);
				}
				return image;
			}
			string fileName = System.IO.Path.Combine(_ImageCacheDir, cacheFileName);
			if (!System.IO.File.Exists(fileName))
				System.IO.File.WriteAllBytes(fileName, Convert.FromBase64String(getDataMethod()));
			if (System.IO.File.Exists(fileName))
				return Image.FromFile(fileName);
			return null;
		}
		/// <summary>
		/// Obsahuje jméno adresáře, který slouží jako Cache pro obrázky systému.
		/// </summary>
		private static string _ImageCacheDir
		{
			get
			{
				string dirName = System.IO.Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.CommonApplicationData), "IconCache");
				if (!System.IO.Directory.Exists(dirName))
					System.IO.Directory.CreateDirectory(dirName);
				return dirName;
			}
		}
		/// <summary>
		/// Předpis pro metody, které generují obsah souboru s daty
		/// </summary>
		/// <returns></returns>
		private delegate string _GetStringDelegate();
		/// <summary>
		/// Vrátí Icon z dat (string), která jsou předána na vstup v kódování Base64
		/// </summary>
		/// <param name="data">Vstupní data v kódování Base64</param>
		/// <returns>Icon vytvořená z dat</returns>
		public static System.Drawing.Icon ConvertStringToIcon(string data)
		{
			System.Drawing.Icon icon;
			using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
			{
				icon = new System.Drawing.Icon(ms);
			}
			return icon;
		}
		/// <summary>
		/// Vrátí Cursor z dat (string), která jsou předána na vstup v kódování Base64
		/// </summary>
		/// <param name="data">Vstupní data v kódování Base64</param>
		/// <returns>Cursor vytvořený z dat</returns>
		public static System.Windows.Forms.Cursor ConvertStringToCursor(string data)
		{
			System.Windows.Forms.Cursor cursor;
			using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
			{
				cursor = new System.Windows.Forms.Cursor(ms);
			}
			return cursor;
		}
		#endregion

	}
}
